package com.ocean.pokesync.data;

import net.william278.husksync.HuskSync;
import net.william278.husksync.data.Serializer;
import org.jetbrains.annotations.NotNull;

public class PixelmonSerializer {

    protected final HuskSync api;

    public PixelmonSerializer(@NotNull HuskSync api) {
        this.api = api;
    }

    public static class PC implements Serializer<PixelmonData.PC> {
        private final Serializer<PixelmonData.PC> delegate;
        public PC(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.PC.class);
        }
        @Override
        public PixelmonData.PC deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.PC element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Party implements Serializer<PixelmonData.Party> {
        private final Serializer<PixelmonData.Party> delegate;
        public Party(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Party.class);
        }
        @Override
        public PixelmonData.Party deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Party element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Pokedex implements Serializer<PixelmonData.Pokedex> {
        private final Serializer<PixelmonData.Pokedex> delegate;
        public Pokedex(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Pokedex.class);
        }
        @Override
        public PixelmonData.Pokedex deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Pokedex element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Stats implements Serializer<PixelmonData.Stats> {
        private final Serializer<PixelmonData.Stats> delegate;
        public Stats(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Stats.class);
        }
        @Override
        public PixelmonData.Stats deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Stats element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Money implements Serializer<PixelmonData.Money> {
        private final Serializer<PixelmonData.Money> delegate;
        public Money(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Money.class);
        }
        @Override
        public PixelmonData.Money deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Money element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Daycare implements Serializer<PixelmonData.Daycare> {
        private final Serializer<PixelmonData.Daycare> delegate;
        public Daycare(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Daycare.class);
        }
        @Override
        public PixelmonData.Daycare deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Daycare element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class MegaItem implements Serializer<PixelmonData.MegaItem> {
        private final Serializer<PixelmonData.MegaItem> delegate;
        public MegaItem(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.MegaItem.class);
        }
        @Override
        public PixelmonData.MegaItem deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.MegaItem element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Charm implements Serializer<PixelmonData.Charm> {
        private final Serializer<PixelmonData.Charm> delegate;
        public Charm(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Charm.class);
        }
        @Override
        public PixelmonData.Charm deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Charm element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Gift implements Serializer<PixelmonData.Gift> {
        private final Serializer<PixelmonData.Gift> delegate;
        public Gift(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Gift.class);
        }
        @Override
        public PixelmonData.Gift deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Gift element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class TrainerCard implements Serializer<PixelmonData.TrainerCard> {
        private final Serializer<PixelmonData.TrainerCard> delegate;
        public TrainerCard(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.TrainerCard.class);
        }
        @Override
        public PixelmonData.TrainerCard deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.TrainerCard element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Cosmetic implements Serializer<PixelmonData.Cosmetic> {
        private final Serializer<PixelmonData.Cosmetic> delegate;
        public Cosmetic(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Cosmetic.class);
        }
        @Override
        public PixelmonData.Cosmetic deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Cosmetic element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Lure implements Serializer<PixelmonData.Lure> {
        private final Serializer<PixelmonData.Lure> delegate;
        public Lure(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Lure.class);
        }
        @Override
        public PixelmonData.Lure deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Lure element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Curry implements Serializer<PixelmonData.Curry> {
        private final Serializer<PixelmonData.Curry> delegate;
        public Curry(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Curry.class);
        }
        @Override
        public PixelmonData.Curry deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Curry element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

    public static class Research implements Serializer<PixelmonData.Research> {
        private final Serializer<PixelmonData.Research> delegate;
        public Research(@NotNull HuskSync api) {
            this.delegate = new Json<>(api, PixelmonData.Research.class);
        }
        @Override
        public PixelmonData.Research deserialize(@NotNull String serialized) throws DeserializationException {
            return delegate.deserialize(serialized);
        }
        @Override
        public @NotNull String serialize(@NotNull PixelmonData.Research element) throws SerializationException {
            return delegate.serialize(element);
        }
    }

}
